home *** CD-ROM | disk | FTP | other *** search
/ Language/OS - Multiplatform Resource Library / LANGUAGE OS.iso / pcl / src-16f.lha / compiler / pack.lisp < prev    next >
Lisp/Scheme  |  1991-11-16  |  54KB  |  1,552 lines
  1. ;;; -*- Package: C; Log: C.Log -*-
  2. ;;;
  3. ;;; **********************************************************************
  4. ;;; This code was written as part of the CMU Common Lisp project at
  5. ;;; Carnegie Mellon University, and has been placed in the public domain.
  6. ;;; If you want to use this code or any part of CMU Common Lisp, please contact
  7. ;;; Scott Fahlman or slisp-group@cs.cmu.edu.
  8. ;;;
  9. (ext:file-comment
  10.   "$Header: pack.lisp,v 1.44 91/11/16 16:03:02 ram Exp $")
  11. ;;;
  12. ;;; **********************************************************************
  13. ;;;
  14. ;;;    This file contains the implementation independent code for Pack phase in
  15. ;;; the compiler.  Pack is responsible for assigning TNs to storage allocations
  16. ;;; or "register allocation".
  17. ;;;
  18. ;;; Written by Rob MacLachlan
  19. ;;;
  20. (in-package 'c)
  21.  
  22. ;;; Some parameters controlling which optimizations we attempt (for debugging.)
  23. ;;;
  24. (defparameter pack-assign-costs t)
  25. (defparameter pack-optimize-saves t)
  26. (defparameter pack-save-once t)
  27.  
  28.  
  29. ;;;; Conflict determination:
  30.  
  31.  
  32. ;;; Offset-Conflicts-In-SB  --  Internal
  33. ;;;
  34. ;;; Return true if the element at the specified offset in SB has a conflict
  35. ;;; with TN:
  36. ;;; -- If an component-live TN (:component kind), then iterate over all the
  37. ;;;    blocks.  If the element at Offset is used anywhere in any of the
  38. ;;;    component's blocks (always-live /= 0), then there is a conflict.
  39. ;;; -- If TN is global (Confs true), then iterate over the blocks TN is live in
  40. ;;;    (using TN-Global-Conflicts).  If the TN is live everywhere in the block
  41. ;;;    (:Live), then there is a conflict if the element at offset is used
  42. ;;;    anywhere in the block (Always-Live /= 0).  Otherwise, we use the local
  43. ;;;    TN number for TN in block to find whether TN has a conflict at Offset in
  44. ;;;    that block.
  45. ;;; -- If TN is local, then we just check for a conflict in the block it is
  46. ;;;    local to.
  47. ;;;
  48. (defun offset-conflicts-in-sb (tn sb offset)
  49.   (declare (type tn tn) (type finite-sb sb) (type index offset))
  50.   (let ((confs (tn-global-conflicts tn))
  51.     (kind (tn-kind tn)))
  52.     (cond
  53.      ((eq kind :component)
  54.       (let ((loc-live (svref (finite-sb-always-live sb) offset)))
  55.     (dotimes (i (ir2-block-count *compile-component*) nil)
  56.       (when (/= (sbit loc-live i) 0)
  57.         (return t)))))
  58.      (confs
  59.       (let ((loc-confs (svref (finite-sb-conflicts sb) offset))
  60.         (loc-live (svref (finite-sb-always-live sb) offset)))
  61.     (do ((conf confs (global-conflicts-tn-next conf)))
  62.         ((null conf)
  63.          nil)
  64.       (let* ((block (global-conflicts-block conf))
  65.          (num (ir2-block-number block)))
  66.         (if (eq (global-conflicts-kind conf) :live)
  67.         (when (/= (sbit loc-live num) 0)
  68.           (return t))
  69.         (when (/= (sbit (svref loc-confs num)
  70.                 (global-conflicts-number conf))
  71.               0)
  72.           (return t)))))))
  73.      (t
  74.       (/= (sbit (svref (svref (finite-sb-conflicts sb) offset)
  75.                (ir2-block-number (tn-local tn)))
  76.         (tn-local-number tn))
  77.       0)))))
  78.  
  79.  
  80. ;;; Conflicts-In-SC  --  Internal
  81. ;;;
  82. ;;;    Return true if TN has a conflict in SC at the specified offset.
  83. ;;;
  84. (defun conflicts-in-sc (tn sc offset)
  85.   (declare (type tn tn) (type sc sc) (type index offset))
  86.   (let ((sb (sc-sb sc)))
  87.     (dotimes (i (sc-element-size sc) nil)
  88.       (when (offset-conflicts-in-sb tn sb (+ offset i))
  89.     (return t)))))
  90.  
  91.  
  92. ;;; Add-Location-Conflicts  --  Internal
  93. ;;;
  94. ;;;    Add TN's conflicts into the conflicts for the location at Offset in SC.
  95. ;;; We iterate over each location in TN, adding to the conflicts for that
  96. ;;; location:
  97. ;;; -- If TN is a :Component TN, then iterate over all the blocks, setting
  98. ;;;    all of the local conflict bits and the always-live bit.  This records a
  99. ;;;    conflict with any TN that has a LTN number in the block, as well as with
  100. ;;;    :Always-Live and :Environment TNs.
  101. ;;; -- If TN is global, then iterate over the blocks TN is live in.  In
  102. ;;;    addition to setting the always-live bit to represent the conflict with
  103. ;;;    TNs live throughout the block, we also set bits in the local conflicts.
  104. ;;;    If TN is :Always-Live in the block, we set all the bits, otherwise we or
  105. ;;;    in the local conflict bits.
  106. ;;; -- If the TN is local, then we just do the block it is local to, setting
  107. ;;;    always-live and OR'ing in the local conflicts.
  108. ;;;
  109. (defun add-location-conflicts (tn sc offset)
  110.   (declare (type tn tn) (type sc sc) (type index offset))
  111.   (let ((confs (tn-global-conflicts tn))
  112.     (sb (sc-sb sc))
  113.     (kind (tn-kind tn)))
  114.     (dotimes (i (sc-element-size sc))
  115.       (let* ((this-offset (+ offset i))
  116.          (loc-confs (svref (finite-sb-conflicts sb) this-offset))
  117.          (loc-live (svref (finite-sb-always-live sb) this-offset)))
  118.     (cond
  119.      ((eq kind :component)
  120.       (dotimes (num (ir2-block-count *compile-component*) nil)
  121.         (setf (sbit loc-live num) 1)
  122.         (set-bit-vector (svref loc-confs num))))
  123.      (confs
  124.       (do ((conf confs (global-conflicts-tn-next conf)))
  125.           ((null conf))
  126.         (let* ((block (global-conflicts-block conf))
  127.            (num (ir2-block-number block))
  128.            (local-confs (svref loc-confs num)))
  129.           (declare (type local-tn-bit-vector local-confs))
  130.           (setf (sbit loc-live num) 1)
  131.           (if (eq (global-conflicts-kind conf) :live)
  132.           (set-bit-vector local-confs)
  133.           (bit-ior local-confs (global-conflicts-conflicts conf) t)))))
  134.      (t
  135.       (let ((num (ir2-block-number (tn-local tn))))
  136.         (setf (sbit loc-live num) 1)
  137.         (bit-ior (the local-tn-bit-vector (svref loc-confs num))
  138.              (tn-local-conflicts tn) t))))))))
  139.  
  140.  
  141. ;;; IR2-BLOCK-COUNT  --  Internal
  142. ;;;
  143. ;;;    Return the total number of IR2 blocks in Component.
  144. ;;;
  145. (defun ir2-block-count (component)
  146.   (declare (type component component))
  147.   (do ((2block (block-info (block-next (component-head component)))
  148.            (ir2-block-next 2block)))
  149.       ((null 2block)
  150.        (error "What?  No ir2 blocks have a non-nil number?"))
  151.     (when (ir2-block-number 2block)
  152.       (return (1+ (ir2-block-number 2block))))))
  153.  
  154.  
  155. ;;; Init-SB-Vectors  --  Internal
  156. ;;;
  157. ;;;    Ensure that the conflicts vectors for each :Finite SB are large enough
  158. ;;; for the number of blocks allocated.  Also clear any old conflicts and reset
  159. ;;; the current size to the initial size.
  160. ;;;
  161. (defun init-sb-vectors (component)
  162.   (let ((nblocks (ir2-block-count component)))
  163.     (dolist (sb (backend-sb-list *backend*))
  164.       (unless (eq (sb-kind sb) :non-packed)
  165.     (let* ((conflicts (finite-sb-conflicts sb))
  166.            (always-live (finite-sb-always-live sb))
  167.            (max-locs (length conflicts)))
  168.       (unless (zerop max-locs)
  169.         (let ((current-size (length (the simple-vector
  170.                          (svref conflicts 0)))))
  171.           (when (> nblocks current-size)
  172.         (let ((new-size (max nblocks (* current-size 2))))
  173.           (dotimes (i (length conflicts))
  174.             (let ((new-vec (make-array new-size)))
  175.               (dotimes (j new-size)
  176.             (setf (svref new-vec j)
  177.                   (make-array local-tn-limit :element-type 'bit)))
  178.               (setf (svref conflicts i) new-vec))
  179.             (setf (svref always-live i)  
  180.               (make-array new-size :element-type 'bit))))))
  181.         
  182.         (dotimes (i (length conflicts))
  183.           (let ((conf (svref conflicts i)))
  184.         (dotimes (j (length conf))
  185.           (clear-bit-vector (svref conf j))))
  186.           (clear-bit-vector (svref always-live i)))))
  187.  
  188.     (setf (finite-sb-current-size sb) (sb-size sb))
  189.     (setf (finite-sb-last-offset sb) 0)))))
  190.  
  191.  
  192. ;;; Grow-SC  --  Internal
  193. ;;;
  194. ;;;    Expand the :Unbounded SB backing SC by either the initial size or the SC
  195. ;;; element size, whichever is larger.  If Needed-Size is larger, then use that
  196. ;;; size.
  197. ;;;
  198. (defun grow-sc (sc &optional (needed-size 0))
  199.   (declare (type sc sc))
  200.   (let* ((sb (sc-sb sc))
  201.      (size (finite-sb-current-size sb))
  202.      (inc (max (sb-size sb)
  203.            (+ (sc-element-size sc)
  204.               (- (* (ceiling size (sc-alignment sc))
  205.                 (sc-alignment sc))
  206.              size))
  207.            (- needed-size size)))
  208.      (new-size (+ size inc))
  209.      (conflicts (finite-sb-conflicts sb))
  210.      (block-size (if (zerop (length conflicts))
  211.              (ir2-block-count *compile-component*)
  212.              (length (the simple-vector (svref conflicts 0))))))
  213.     (assert (eq (sb-kind sb) :unbounded))
  214.  
  215.     (when (> new-size (length conflicts))
  216.       (let ((new-conf (make-array new-size)))
  217.     (replace new-conf conflicts)
  218.     (do ((i size (1+ i)))
  219.         ((= i new-size))
  220.       (let ((loc-confs (make-array block-size)))
  221.         (dotimes (j block-size)
  222.           (setf (svref loc-confs j)
  223.             (make-array local-tn-limit
  224.                 :initial-element 0
  225.                 :element-type 'bit)))
  226.         (setf (svref new-conf i) loc-confs)))
  227.     (setf (finite-sb-conflicts sb) new-conf))
  228.       
  229.       (let ((new-live (make-array new-size)))
  230.     (replace new-live (finite-sb-always-live sb))
  231.     (do ((i size (1+ i)))
  232.         ((= i new-size))
  233.       (setf (svref new-live i)
  234.         (make-array block-size
  235.                 :initial-element 0
  236.                 :element-type 'bit)))
  237.     (setf (finite-sb-always-live sb) new-live))
  238.  
  239.       (let ((new-tns (make-array new-size :initial-element nil)))
  240.     (replace new-tns (finite-sb-live-tns sb))
  241.     (fill (finite-sb-live-tns sb) nil) 
  242.     (setf (finite-sb-live-tns sb) new-tns)))
  243.  
  244.     (setf (finite-sb-current-size sb) new-size))
  245.   (undefined-value))
  246.  
  247.  
  248. ;;; This variable is true whenever we are in pack (and thus the per-SB
  249. ;;; conflicts information is in use.)
  250. ;;;
  251. (defvar *in-pack* nil)
  252.  
  253.  
  254. ;;; Pack-Before-GC-Hook  --  Internal
  255. ;;;
  256. ;;;    In order to prevent the conflict data structures from growing
  257. ;;; arbitrarily large, we clear them whenever a GC happens and we aren't
  258. ;;; currently in pack.  We revert to the initial number of locations and 0
  259. ;;; blocks.
  260. ;;;
  261. (defun pack-before-gc-hook ()
  262.   (unless *in-pack*
  263.     (dolist (sb (backend-sb-list *backend*))
  264.       (unless (eq (sb-kind sb) :non-packed)
  265.     (let ((size (sb-size sb)))
  266.       (fill nil (finite-sb-always-live sb))
  267.       (setf (finite-sb-always-live sb)
  268.         (make-array size :initial-element #*))
  269.       
  270.       (fill nil (finite-sb-conflicts sb))
  271.       (setf (finite-sb-conflicts sb)
  272.         (make-array size :initial-element '#()))
  273.       
  274.       (fill nil (finite-sb-live-tns sb))
  275.       (setf (finite-sb-live-tns sb)
  276.         (make-array size :initial-element nil))))))
  277.   (undefined-value))
  278.  
  279. (pushnew 'pack-before-gc-hook ext:*before-gc-hooks*)
  280.  
  281.  
  282. ;;;; Internal errors:
  283.  
  284. ;;; NO-LOAD-FUNCTION-ERROR  --  Internal
  285. ;;;
  286. ;;;    Give someone a hard time because there isn't any load function defined
  287. ;;; to move from Src to Dest.
  288. ;;;
  289. (defun no-load-function-error (src dest)
  290.   (let* ((src-sc (tn-sc src))
  291.      (src-name (sc-name src-sc))
  292.      (dest-sc (tn-sc dest))
  293.      (dest-name (sc-name dest-sc)))
  294.     (cond ((eq (sb-kind (sc-sb src-sc)) :non-packed)
  295.        (unless (member src-sc (sc-constant-scs dest-sc))
  296.          (error "Loading from an invalid constant SC?~@
  297.                  VM definition inconsistent, try recompiling."))
  298.        (error "No load function defined to load SC ~S ~
  299.                from its constant SC ~S."
  300.           dest-name src-name))
  301.       ((member src-sc (sc-alternate-scs dest-sc))
  302.        (error "No load function defined to load SC ~S from its ~
  303.                alternate SC ~S."
  304.           dest-name src-name))
  305.       ((member dest-sc (sc-alternate-scs src-sc))
  306.        (error "No load function defined to save SC ~S in its ~
  307.                alternate SC ~S."
  308.           src-name dest-name))
  309.       (t
  310.        (error "Loading to/from SCs that aren't alternates?~@
  311.                VM definition inconsistent, try recompiling.")))))
  312.  
  313.  
  314. ;;; FAILED-TO-PACK-ERROR  --  Internal
  315. ;;;
  316. ;;;    Called when we failed to pack TN.  If Restricted is true, then we we
  317. ;;; restricted to pack TN in its SC. 
  318. ;;;
  319. (defun failed-to-pack-error (tn restricted)
  320.   (declare (type tn tn))
  321.   (let* ((sc (tn-sc tn))
  322.      (scs (cons sc (sc-alternate-scs sc))))
  323.     (cond
  324.      (restricted
  325.       (error "Failed to pack restricted TN ~S in its SC ~S."
  326.          tn (sc-name sc)))
  327.      (t
  328.       (assert (not (find :unbounded scs
  329.              :key #'(lambda (x) (sb-kind (sc-sb x))))))
  330.       (let ((ptype (tn-primitive-type tn)))
  331.     (cond
  332.      (ptype
  333.       (assert (member (sc-number sc) (primitive-type-scs ptype)))
  334.       (error "SC ~S doesn't have any :Unbounded alternate SCs, but is~@
  335.               a SC for primitive-type ~S."
  336.          (sc-name sc) (primitive-type-name ptype)))
  337.      (t
  338.       (error "SC ~S doesn't have any :Unbounded alternate SCs."
  339.          (sc-name sc))))))))
  340.   (undefined-value))
  341.  
  342.  
  343. ;;; DESCRIBE-TN-USE  --  Internal
  344. ;;;
  345. ;;;    Return a list of format arguments describing how TN is used in Op's VOP.
  346. ;;;
  347. (defun describe-tn-use (loc tn op)
  348.   (let* ((vop (tn-ref-vop op))
  349.      (args (vop-args vop))
  350.      (results (vop-results vop))
  351.      (name (with-output-to-string (stream)
  352.          (print-tn tn stream)))
  353.      temp)
  354.     (cond
  355.      ((setq temp (position-in #'tn-ref-across tn args :key #'tn-ref-tn))
  356.       `("~2D: ~A (~:R argument)" ,loc ,name ,(1+ temp)))
  357.      ((setq temp (position-in #'tn-ref-across tn results :key #'tn-ref-tn))
  358.       `("~2D: ~A (~:R result)" ,loc ,name ,(1+ temp)))
  359.      ((setq temp (position-in #'tn-ref-across tn args :key #'tn-ref-load-tn))
  360.       `("~2D: ~A (~:R argument load TN)" ,loc ,name ,(1+ temp)))
  361.      ((setq temp (position-in #'tn-ref-across tn results :key
  362.                   #'tn-ref-load-tn))
  363.       `("~2D: ~A (~:R result load TN)" ,loc ,name ,(1+ temp)))
  364.      ((setq temp (position-in #'tn-ref-across tn (vop-temps vop)
  365.                   :key #'tn-ref-tn))
  366.       `("~2D: ~A (temporary ~A)" ,loc ,name
  367.     ,(operand-parse-name (elt (vop-parse-temps
  368.                    (vop-parse-or-lose
  369.                     (vop-info-name  (vop-info vop))))
  370.                   temp))))
  371.      ((eq (tn-kind tn) :component)
  372.       `("~2D: ~A (component live)" ,loc ,name))
  373.      (t
  374.       `("~2D: not referenced?" ,loc)))))
  375.  
  376.  
  377. ;;; FAILED-TO-PACK-LOAD-TN-ERROR  --  Internal
  378. ;;;
  379. ;;;    If load TN packing fails, try to give a helpful error message.  We find
  380. ;;; a TN in each location that conflicts, and print it.
  381. ;;;
  382. (defun failed-to-pack-load-tn-error (scs op)
  383.   (declare (list scs) (type tn-ref op))
  384.   (collect ((used)
  385.         (unused))
  386.     (dolist (sc scs)
  387.       (let* ((sb (sc-sb sc))
  388.          (confs (finite-sb-live-tns sb)))
  389.     (assert (eq (sb-kind sb) :finite))
  390.     (dolist (el (sc-locations sc))
  391.       (let ((conf (load-tn-conflicts-in-sc op sc el t)))
  392.         (if conf
  393.         (used (describe-tn-use el conf op))
  394.         (loop for i from el
  395.               as victim = (svref confs i)
  396.               repeat (sc-element-size sc) do
  397.           (when (and victim (eq (tn-kind victim) :component))
  398.             (used (describe-tn-use el victim op))
  399.             (return t))
  400.           finally (unused el)))))))
  401.       
  402.     (multiple-value-bind (arg-p n more-p costs load-scs incon)
  403.              (get-operand-info op)
  404.     (declare (ignore costs load-scs))
  405.     (assert (not more-p))
  406.     (error "Unable to pack a Load-TN in SC ~{~A~#[~^~;, or ~:;,~]~} ~
  407.         for the ~:R ~:[result~;argument~] to~@
  408.         the ~S VOP,~@
  409.         ~:[since all SC elements are in use:~:{~%~@?~}~%~;~
  410.         ~:*but these SC elements are not in use:~%  ~S~%Bug?~*~]~
  411.         ~:[~;~@
  412.         Current cost info inconsistent with that in effect at compile ~
  413.         time.  Recompile.~%Compilation order may be incorrect.~]"
  414.            (mapcar #'sc-name scs)
  415.            n arg-p
  416.            (vop-info-name (vop-info (tn-ref-vop op)))
  417.            (unused) (used)
  418.            incon)))
  419.   (undefined-value))
  420.  
  421.  
  422. ;;; NO-LOAD-SCS-ALLOWED-BY-PRIMITIVE-TYPE-ERROR  --  Internal
  423. ;;;
  424. ;;;    Called when none of the SCs that we can load Op into are allowed by Op's
  425. ;;; primitive-type.
  426. ;;;
  427. (defun no-load-scs-allowed-by-primitive-type-error (ref)
  428.   (declare (type tn-ref ref))
  429.   (let* ((tn (tn-ref-tn ref))
  430.      (ptype (tn-primitive-type tn)))
  431.     (multiple-value-bind (arg-p pos more-p costs load-scs incon)
  432.              (get-operand-info ref)
  433.       (declare (ignore costs))
  434.       (assert (not more-p))
  435.       (error "~S is not valid as the ~:R ~:[result~;argument~] to VOP:~
  436.               ~%  ~S,~@
  437.           since the TN's primitive type ~S doesn't allow any of the SCs~@
  438.           allowed by the operand restriction:~%  ~S~
  439.           ~:[~;~@
  440.           Current cost info inconsistent with that in effect at compile ~
  441.           time.  Recompile.~%Compilation order may be incorrect.~]"
  442.          tn pos arg-p
  443.          (template-name (vop-info (tn-ref-vop ref)))
  444.          (primitive-type-name ptype)
  445.          (mapcar #'sc-name (listify-restrictions load-scs))
  446.          incon)))
  447.   (undefined-value))
  448.  
  449.  
  450. ;;;; Register saving:
  451.  
  452. ;;; Original-TN  --  Internal
  453. ;;;
  454. ;;;    If a save TN, return the saved TN, otherwise return TN.  Useful for
  455. ;;; getting the conflicts of a TN that might be a save TN.
  456. ;;;
  457. (defun original-tn (tn)
  458.   (declare (type tn tn))
  459.   (if (member (tn-kind tn) '(:save :save-once :specified-save))
  460.       (tn-save-tn tn)
  461.       tn))
  462.  
  463.  
  464. ;;; Note-Spilled-TN  --  Internal
  465. ;;;
  466. ;;;    Do stuff to note that TN is spilled at VOP for the debugger's benefit.
  467. ;;;
  468. (defun note-spilled-tn (tn vop)
  469.   (when (and (tn-leaf tn) (vop-save-set vop))
  470.     (let ((2comp (component-info *compile-component*)))
  471.       (setf (gethash tn (ir2-component-spilled-tns 2comp)) t)
  472.       (pushnew tn (gethash vop (ir2-component-spilled-vops 2comp)))))
  473.   (undefined-value))
  474.  
  475.  
  476. ;;; Pack-Save-TN  --  Internal
  477. ;;;
  478. ;;;    Make a save TN for TN, pack it, and return it.  We copy various conflict
  479. ;;; information from the TN so that pack does the right thing.
  480. ;;;    
  481. (defun pack-save-tn (tn)
  482.   (declare (type tn tn))
  483.   (let ((res (make-tn 0 :save nil nil)))
  484.     (dolist (alt (sc-alternate-scs (tn-sc tn))
  485.          (error "No unbounded alternate for SC ~S."
  486.             (sc-name (tn-sc tn))))
  487.       (when (eq (sb-kind (sc-sb alt)) :unbounded)
  488.     (setf (tn-save-tn tn) res)
  489.     (setf (tn-save-tn res) tn)
  490.     (setf (tn-sc res) alt)
  491.     (pack-tn res t)
  492.     (return res)))))
  493.  
  494.  
  495. ;;; EMIT-OPERAND-LOAD  --  Internal
  496. ;;;
  497. ;;;    Find the load function for moving from Src to Dest and emit a
  498. ;;; MOVE-OPERAND VOP with that function as its info arg.
  499. ;;;
  500. (defun emit-operand-load (node block src dest before)
  501.   (declare (type node node) (type ir2-block block)
  502.        (type tn src dest) (type (or vop null) before))
  503.   (emit-load-template node block
  504.               (template-or-lose 'move-operand *backend*)
  505.               src dest
  506.               (list (or (svref (sc-move-functions (tn-sc dest))
  507.                        (sc-number (tn-sc src)))
  508.                 (no-load-function-error src dest)))
  509.               before)
  510.   (undefined-value))
  511.  
  512.  
  513. ;;; REVERSE-FIND-VOP  --  Internal
  514. ;;;
  515. ;;;    Find the preceding use of the VOP NAME in the emit order, starting with
  516. ;;; VOP.  We must find the VOP in the same IR1 block.
  517. ;;;
  518. (defun reverse-find-vop (name vop)
  519.   (do* ((block (vop-block vop) (ir2-block-prev block))
  520.     (last vop (ir2-block-last-vop block)))
  521.        (nil)
  522.     (assert (eq (ir2-block-block block) (ir2-block-block (vop-block vop))))
  523.     (do ((current last (vop-prev current)))
  524.     ((null current))
  525.       (when (eq (vop-info-name (vop-info current)) name)
  526.     (return-from reverse-find-vop current)))))
  527.  
  528.  
  529. ;;; Save-Complex-Writer-TN  --  Internal
  530. ;;;
  531. ;;;    For TNs that have other than one writer, we save the TN before each
  532. ;;; call.  If a local call (MOVE-ARGS is :LOCAL-CALL), then we scan back for
  533. ;;; the ALLOCATE-FRAME VOP, and emit the save there.  This is necessary because
  534. ;;; in a self-recursive local call, the registers holding the current arguments
  535. ;;; may get trashed by setting up the call arguments.  The ALLOCATE-FRAME VOP
  536. ;;; marks a place at which the values are known to be good.
  537. ;;;
  538. (defun save-complex-writer-tn (tn vop)
  539.   (let ((save (or (tn-save-tn tn)
  540.           (pack-save-tn tn)))
  541.     (node (vop-node vop))
  542.     (block (vop-block vop))
  543.     (next (vop-next vop)))
  544.     (when (eq (tn-kind save) :specified-save)
  545.       (setf (tn-kind save) :save))
  546.     (assert (eq (tn-kind save) :save))
  547.     (emit-operand-load node block tn save
  548.                (if (eq (vop-info-move-args (vop-info vop))
  549.                    :local-call)
  550.                (reverse-find-vop 'allocate-frame vop)
  551.                vop))
  552.     (emit-operand-load node block save tn next)))
  553.  
  554.  
  555. ;;; FIND-SINGLE-WRITER  --  Internal
  556. ;;;
  557. ;;;    Return a VOP after which is an o.k. place to save the value of TN.  For
  558. ;;; correctness, it is only required that this location be after any possible
  559. ;;; write and before any possible restore location.
  560. ;;;
  561. ;;;    In practice, we return the unique writer VOP, but give up if the TN is
  562. ;;; ever read by a VOP with MOVE-ARGS :LOCAL-CALL.  This prevents us from being
  563. ;;; confused by non-tail local calls.
  564. ;;;
  565. ;;; When looking for writes, we have to ignore uses of MOVE-OPERAND, since they
  566. ;;; will correspond to restores that we have already done.
  567. ;;;
  568. (defun find-single-writer (tn)
  569.   (declare (type tn tn))
  570.   (do ((write (tn-writes tn) (tn-ref-next write))
  571.        (res nil))
  572.       ((null write)
  573.        (when (and res
  574.           (loop for read = (tn-reads tn) then (tn-ref-next read)
  575.                 while read
  576.                 never (eq (vop-info-move-args
  577.                    (vop-info
  578.                     (tn-ref-vop read)))
  579.                   :local-call)))
  580.      (tn-ref-vop res)))
  581.  
  582.     (unless (eq (vop-info-name (vop-info (tn-ref-vop write)))
  583.         'move-operand)
  584.       (when res (return nil))
  585.       (setq res write))))
  586.  
  587.  
  588. ;;; Save-Single-Writer-TN  --  Internal
  589. ;;;
  590. ;;;    Try to save TN at a single location.  If we succeed, return T, otherwise
  591. ;;; NIL.
  592. ;;;
  593. (defun save-single-writer-tn (tn)
  594.   (declare (type tn tn))
  595.   (let* ((old-save (tn-save-tn tn))
  596.      (save (or old-save (pack-save-tn tn)))
  597.      (writer (find-single-writer tn)))
  598.     (when (and writer
  599.            (or (not old-save)
  600.            (eq (tn-kind old-save) :specified-save)))
  601.       (emit-operand-load (vop-node writer) (vop-block writer)
  602.              tn save (vop-next writer))
  603.       (setf (tn-kind save) :save-once)
  604.       t)))
  605.  
  606.  
  607. ;;; RESTORE-SINGLE-WRITER-TN  --  Internal
  608. ;;;
  609. ;;;    Restore a TN with a :SAVE-ONCE save TN.
  610. ;;;
  611. (defun restore-single-writer-tn (tn vop)
  612.   (declare (type tn) (type vop vop))
  613.   (let ((save (tn-save-tn tn)))
  614.     (assert (eq (tn-kind save) :save-once))
  615.     (emit-operand-load (vop-node vop) (vop-block vop) save tn (vop-next vop)))
  616.   (undefined-value))
  617.  
  618.  
  619. ;;; BASIC-SAVE-TN  --  Internal
  620. ;;;
  621. ;;;    Save a single TN that needs to be saved, choosing save-once if
  622. ;;; appropriate.  This is also called by SPILL-AND-PACK-LOAD-TN.
  623. ;;;
  624. (defun basic-save-tn (tn vop)
  625.   (declare (type tn tn) (type vop vop))
  626.   (let ((save (tn-save-tn tn)))
  627.     (cond ((and save (eq (tn-kind save) :save-once))
  628.        (restore-single-writer-tn tn vop))
  629.       ((save-single-writer-tn tn)
  630.        (restore-single-writer-tn tn vop))
  631.       (t
  632.        (save-complex-writer-tn tn vop))))
  633.   (undefined-value))
  634.  
  635.  
  636. ;;; Emit-Saves  --  Internal
  637. ;;;
  638. ;;;    Scan over the VOPs in Block, emiting saving code for TNs noted in the
  639. ;;; codegen info that are packed into saved SCs.
  640. ;;;
  641. (defun emit-saves (block)
  642.   (declare (type ir2-block block))
  643.   (do ((vop (ir2-block-start-vop block) (vop-next vop)))
  644.       ((null vop))
  645.     (when (eq (vop-info-save-p (vop-info vop)) t)
  646.       (do-live-tns (tn (vop-save-set vop) block)
  647.     (when (and (sc-save-p (tn-sc tn))
  648.            (not (eq (tn-kind tn) :component)))
  649.       (basic-save-tn tn vop)))))
  650.  
  651.   (undefined-value))
  652.  
  653.  
  654. ;;;; Optimized saving:
  655.  
  656.  
  657. ;;; SAVE-IF-NECESSARY  --  Internal
  658. ;;;
  659. ;;;    Save TN if it isn't a single-writer TN that has already been saved.  If
  660. ;;; multi-write, we insert the save Before the specified VOP.  Context is a VOP
  661. ;;; used to tell which node/block to use for the new VOP.
  662. ;;;
  663. (defun save-if-necessary (tn before context)
  664.   (declare (type tn tn) (type (or vop null) before) (type vop context))
  665.   (let ((save (tn-save-tn tn)))
  666.     (when (eq (tn-kind save) :specified-save)
  667.       (setf (tn-kind save) :save))
  668.     (assert (member (tn-kind save) '(:save :save-once)))
  669.     (unless (eq (tn-kind save) :save-once)
  670.       (or (save-single-writer-tn tn)
  671.       (emit-operand-load (vop-node context) (vop-block context)
  672.                  tn save before))))
  673.   (undefined-value))
  674.  
  675.  
  676. ;;; RESTORE-TN  --  Internal
  677. ;;;
  678. ;;;    Load the TN from its save location, allocating one if necessary.  The
  679. ;;; load is inserted Before the specifier VOP.  Context is a VOP used to tell
  680. ;;; which node/block to use for the new VOP.
  681. ;;;
  682. (defun restore-tn (tn before context)
  683.   (declare (type tn tn) (type (or vop null) before) (type vop context))
  684.   (let ((save (or (tn-save-tn tn) (pack-save-tn tn))))
  685.     (emit-operand-load (vop-node context) (vop-block context)
  686.                save tn before))
  687.   (undefined-value))
  688.  
  689.  
  690. (eval-when (compile eval)
  691.  
  692. ;;; SAVE-NOTE-READ  --  Internal
  693. ;;;
  694. ;;;    Do stuff to note a read of TN, for OPTIMIZED-EMIT-SAVES-BLOCK.
  695. ;;;
  696. (defmacro save-note-read (tn)
  697.   `(let* ((tn ,tn)
  698.       (num (tn-number tn)))
  699.      (when (and (sc-save-p (tn-sc tn))
  700.         (zerop (sbit restores num))
  701.         (not (eq (tn-kind tn) :component)))
  702.        (setf (sbit restores num) 1)
  703.        (push tn restores-list))))
  704.  
  705. ); Eval-When (Compile Eval)
  706.  
  707. ;;; OPTIMIZED-EMIT-SAVES-BLOCK  --  Internal
  708. ;;;
  709. ;;;    Start scanning backward at the end of Block, looking which TNs are live
  710. ;;; and looking for places where we have to save.  We manipulate two sets:
  711. ;;; SAVES and RESTORES.
  712. ;;;
  713. ;;;    SAVES is a set of all the TNs that have to be saved because they are
  714. ;;; restored after some call.  We normally delay saving until the beginning of
  715. ;;; the block, but we must save immediately if we see a write of the saved TN.
  716. ;;; We also immediately save all TNs and exit when we see a
  717. ;;; NOTE-ENVIRONMENT-START VOP, since saves can't be done before the
  718. ;;; environment is properly initialized.
  719. ;;;
  720. ;;;    RESTORES is a set of all the TNs read (and not written) between here and
  721. ;;; the next call, i.e. the set of TNs that must be restored when we reach the
  722. ;;; next (earlier) call VOP.   Unlike SAVES, this set is cleared when we do
  723. ;;; the restoring after a call.  Any TNs that were in RESTORES are moved into
  724. ;;; SAVES to ensure that they are saved at some point.
  725. ;;;
  726. ;;;    SAVES and RESTORES are represented using both a list and a bit-vector so
  727. ;;; that we can quickly iterate and test for membership.  The incoming Saves
  728. ;;; and Restores args are used for computing these sets (the initial contents
  729. ;;; are ignored.)
  730. ;;;
  731. ;;;    When we hit a VOP with :COMPUTE-ONLY Save-P (an internal error
  732. ;;; location), we pretend that all live TNs were read, unless (= speed 3), in
  733. ;;; which case we mark all the TNs that are live but not restored as spilled.
  734. ;;;
  735. (defun optimized-emit-saves-block (block saves restores)
  736.   (declare (type ir2-block block) (type simple-bit-vector saves restores))
  737.   (let ((1block (ir2-block-block block))
  738.     (saves-list ())
  739.     (restores-list ())
  740.     (skipping nil))
  741.     (clear-bit-vector saves)
  742.     (clear-bit-vector restores)
  743.     (do-live-tns (tn (ir2-block-live-in block) block)
  744.       (when (and (sc-save-p (tn-sc tn))
  745.          (not (eq (tn-kind tn) :component)))
  746.     (let ((num (tn-number tn)))
  747.       (setf (sbit restores num) 1)
  748.       (push tn restores-list))))
  749.  
  750.     (do ((block block (ir2-block-prev block))
  751.      (prev nil block))
  752.     ((not (eq (ir2-block-block block) 1block))
  753.      (assert (not skipping))
  754.      (dolist (save saves-list)
  755.        (let ((start (ir2-block-start-vop prev)))
  756.          (save-if-necessary save start start)))
  757.      prev)
  758.       (do ((vop (ir2-block-last-vop block) (vop-prev vop)))
  759.       ((null vop))
  760.     (let ((info (vop-info vop)))
  761.       (case (vop-info-name info)
  762.         (allocate-frame
  763.          (assert skipping)
  764.          (setq skipping nil))
  765.         (note-environment-start
  766.          (assert (not skipping))
  767.          (dolist (save saves-list)
  768.            (save-if-necessary save (vop-next vop) vop))
  769.          (return-from optimized-emit-saves-block block)))
  770.       
  771.       (unless skipping
  772.         (do ((write (vop-results vop) (tn-ref-across write)))
  773.         ((null write))
  774.           (let* ((tn (tn-ref-tn write))
  775.              (num (tn-number tn)))
  776.         (unless (zerop (sbit restores num))
  777.           (setf (sbit restores num) 0)
  778.           (setq restores-list (delete tn restores-list)))
  779.         (unless (zerop (sbit saves num))
  780.           (setf (sbit saves num) 0)
  781.           (save-if-necessary tn (vop-next vop) vop)
  782.           (setq saves-list (delete tn saves-list))))))
  783.  
  784.       (case (vop-info-save-p info)
  785.         ((t)
  786.          (dolist (tn restores-list)
  787.            (restore-tn tn (vop-next vop) vop)
  788.            (let ((num (tn-number tn)))
  789.          (when (zerop (sbit saves num))
  790.            (push tn saves-list)
  791.            (setf (sbit saves num) 1))))
  792.          (setq restores-list nil)
  793.          (clear-bit-vector restores))
  794.         (:compute-only
  795.          (cond ((policy (vop-node vop) (= speed 3))
  796.             (do-live-tns (tn (vop-save-set vop) block)
  797.               (when (zerop (sbit restores (tn-number tn)))
  798.             (note-spilled-tn tn vop))))
  799.            (t
  800.             (do-live-tns (tn (vop-save-set vop) block)
  801.               (save-note-read tn))))))
  802.       
  803.       (if (eq (vop-info-move-args info) :local-call)
  804.           (setq skipping t)
  805.           (do ((read (vop-args vop) (tn-ref-across read)))
  806.           ((null read))
  807.         (save-note-read (tn-ref-tn read)))))))))
  808.     
  809.  
  810. ;;; OPTIMIZED-EMIT-SAVES  --  Internal
  811. ;;;
  812. ;;;    Like EMIT-SAVES, only different.  We avoid redundant saving within the
  813. ;;; block, and don't restore values that aren't used before the next call.
  814. ;;; This function is just the top-level loop over the blocks in the component,
  815. ;;; which locates blocks that need saving done.
  816. ;;;
  817. (defun optimized-emit-saves (component)
  818.   (declare (type component component))
  819.   (let* ((gtn-count (1+ (ir2-component-global-tn-counter
  820.              (component-info component))))
  821.      (saves (make-array gtn-count :element-type 'bit))
  822.      (restores (make-array gtn-count :element-type 'bit))
  823.      (block (ir2-block-prev (block-info (component-tail component))))
  824.      (head (block-info (component-head component))))
  825.     (loop
  826.       (when (eq block head) (return))
  827.       (when (do ((vop (ir2-block-start-vop block) (vop-next vop)))
  828.         ((null vop) nil)
  829.           (when (eq (vop-info-save-p (vop-info vop)) t)
  830.         (return t)))
  831.     (setq block (optimized-emit-saves-block block saves restores)))
  832.       (setq block (ir2-block-prev block)))))
  833.  
  834.  
  835. ;;; ASSIGN-TN-COSTS  --  Internal
  836. ;;;
  837. ;;;    Iterate over the normal TNs, finding the cost of packing on the stack in
  838. ;;; units of the number of references.  We count all references as +1, and
  839. ;;; subtract out REGISTER-SAVE-PENALTY for each place where we would have to
  840. ;;; save a register.
  841. ;;;
  842. (defun assign-tn-costs (component)
  843.   (do-ir2-blocks (block component)
  844.     (do ((vop (ir2-block-start-vop block) (vop-next vop)))
  845.     ((null vop))
  846.       (when (eq (vop-info-save-p (vop-info vop)) t)
  847.     (do-live-tns (tn (vop-save-set vop) block)
  848.       (decf (tn-cost tn) (backend-register-save-penalty *backend*))))))
  849.   
  850.   (do ((tn (ir2-component-normal-tns (component-info component))
  851.        (tn-next tn)))
  852.       ((null tn))
  853.     (let ((cost (tn-cost tn)))
  854.       (declare (fixnum cost))
  855.       (do ((ref (tn-reads tn) (tn-ref-next ref)))
  856.       ((null ref))
  857.     (incf cost))
  858.       (do ((ref (tn-writes tn) (tn-ref-next ref)))
  859.       ((null ref))
  860.     (incf cost))
  861.       (setf (tn-cost tn) cost))))
  862.  
  863.  
  864. ;;;; Targeting:
  865.  
  866. ;;; Target-If-Desirable  --  Internal
  867. ;;;
  868. ;;;    Link the TN-Refs Read and Write together using the TN-Ref-Target when
  869. ;;; this seems like a good idea.  Currently we always do, as this increases the
  870. ;;; sucess of load-TN targeting.
  871. ;;;
  872. (defun target-if-desirable (read write)
  873.   (declare (type tn-ref read write))
  874.   (setf (tn-ref-target read) write)
  875.   (setf (tn-ref-target write) read))
  876.  
  877.  
  878. ;;; Check-OK-Target  --  Internal
  879. ;;;
  880. ;;;    If TN can be packed into SC so as to honor a preference to Target, then
  881. ;;; return the offset to pack at, otherwise return NIL.  Target must be already
  882. ;;; packed.  We can honor a preference if:
  883. ;;; -- Target's location is in SC's locations.
  884. ;;; -- The element sizes of the two SCs are the same.
  885. ;;; -- TN doesn't conflict with target's location.
  886. ;;; 
  887. (defun check-ok-target (target tn sc)
  888.   (declare (type tn target tn) (type sc sc) (inline member))
  889.   (let* ((loc (tn-offset target))
  890.      (target-sc (tn-sc target))
  891.      (target-sb (sc-sb target-sc)))
  892.     (declare (type index loc))
  893.     (if (and (eq target-sb (sc-sb sc))
  894.          (or (eq (sb-kind target-sb) :unbounded)
  895.          (member loc (sc-locations sc)))
  896.          (= (sc-element-size target-sc) (sc-element-size sc))
  897.          (not (conflicts-in-sc tn sc loc))
  898.          (zerop (mod loc (sc-alignment sc))))
  899.     loc
  900.     nil)))
  901.  
  902.  
  903. ;;; Find-OK-Target-Offset  --  Internal
  904. ;;;
  905. ;;;    Scan along the target path from TN, looking at readers or writers.  When
  906. ;;; we find a packed TN, return Check-OK-Target of that TN.  If there is no
  907. ;;; target, or if the TN has multiple readers (writers), then we return NIL.
  908. ;;; We also always return NIL after 10 iterations to get around potential
  909. ;;; circularity problems.
  910. ;;;
  911. (macrolet ((frob (slot)
  912.          `(let ((count 10)
  913.             (current tn))
  914.         (declare (type index count))
  915.         (loop
  916.           (let ((refs (,slot current)))
  917.             (unless (and (plusp count) refs (not (tn-ref-next refs)))
  918.               (return nil))
  919.             (let ((target (tn-ref-target refs)))
  920.               (unless target (return nil))
  921.               (setq current (tn-ref-tn target))
  922.               (when (tn-offset current)
  923.             (return (check-ok-target current tn sc)))
  924.               (decf count)))))))
  925.   (defun find-ok-target-offset (tn sc)
  926.     (declare (type tn tn) (type sc sc))
  927.     (or (frob tn-reads)
  928.     (frob tn-writes))))
  929.  
  930.  
  931.  
  932. ;;;; Location selection:
  933.  
  934. ;;; Select-Location  --  Internal
  935. ;;;
  936. ;;;    Select some location for TN in SC, returning the offset if we succeed,
  937. ;;; and NIL if we fail.  We start scanning at the Last-Offset in an attempt
  938. ;;; to distribute the TNs across all storage.
  939. ;;;
  940. ;;; We call Offset-Conflicts-In-SB directly, rather than using Conflicts-In-SC.
  941. ;;; This allows us to more efficient in packing multi-location TNs: we don't
  942. ;;; have to multiply the number of tests by the TN size.  This falls out
  943. ;;; natually, since we have to be aware of TN size anyway so that we don't call
  944. ;;; Conflicts-In-SC on a bogus offset.
  945. ;;;
  946. ;;; We give up on finding a location after our current pointer has wrapped
  947. ;;; twice.  This will result in testing some locations twice in the case that
  948. ;;; we fail, but is simpler than trying to figure out the soonest failure
  949. ;;; point.
  950. ;;;
  951. ;;; We also give up without bothering to wrap if the current size isn't large
  952. ;;; enough to hold a single element of element-size without bothering to wrap.
  953. ;;; If it doesn't fit this iteration, it won't fit next.
  954. ;;; 
  955. ;;; ### Note that we actually try to pack as many consecutive TNs as possible
  956. ;;; in the same location, since we start scanning at the same offset that the
  957. ;;; last TN was successfully packed in.  This is a weakening of the scattering
  958. ;;; hueristic that was put in to prevent restricted VOP temps from hogging all
  959. ;;; of the registers.  This way, all of these temps probably end up in one
  960. ;;; register.
  961. ;;;
  962. (defun select-location (tn sc)
  963.   (declare (type tn tn) (type sc sc) (inline member))
  964.   (let* ((sb (sc-sb sc))
  965.      (element-size (sc-element-size sc))
  966.      (alignment (sc-alignment sc))
  967.      (size (finite-sb-current-size sb))
  968.      (start-offset (finite-sb-last-offset sb)))
  969.     (let ((current-start (* (the index (ceiling start-offset alignment))
  970.                 alignment))
  971.       (wrap-p nil))
  972.       (declare (type index current-start))
  973.       (loop
  974.     (when (> (+ current-start element-size) size)
  975.       (cond ((or wrap-p (> element-size size))
  976.          (return nil))
  977.         (t
  978.          (setq current-start 0)
  979.          (setq wrap-p t))))
  980.  
  981.     (if (or (eq (sb-kind sb) :unbounded)
  982.         (and (member current-start (sc-locations sc))
  983.              (not (member current-start (sc-reserve-locations sc)))))
  984.         (dotimes (i element-size
  985.             (return-from select-location current-start))
  986.           (let ((offset (+ current-start i)))
  987.         (when (offset-conflicts-in-sb tn sb offset)
  988.           (setq current-start
  989.             (* (the index (ceiling (1+ offset) alignment))
  990.                alignment))
  991.           (return))))
  992.         (incf current-start alignment))))))
  993.  
  994.  
  995. ;;;; Load TN packing:
  996.  
  997.  
  998. ;;; These variables indicate the last location at which we computed the
  999. ;;; Live-TNs.  They hold the Block and VOP values that were passed to
  1000. ;;; Compute-Live-TNs.
  1001. ;;;
  1002. (defvar *live-block*)
  1003. (defvar *live-vop*)
  1004.  
  1005. ;;; If we unpack some TNs, then we mark all affected blocks by sticking them in
  1006. ;;; this hash-table.  This is initially null.  We create the hashtable if we do
  1007. ;;; any unpacking.
  1008. ;;;
  1009. (defvar *repack-blocks*)
  1010. (declaim (type (or hash-table null) *repack-blocks*))
  1011.  
  1012. ;;; Init-Live-TNs  --  Internal
  1013. ;;;
  1014. ;;;    Set the Live-TNs vectors in all :Finite SBs to represent the TNs live at
  1015. ;;; the end of Block.
  1016. ;;;
  1017. (defun init-live-tns (block)
  1018.   (dolist (sb (backend-sb-list *backend*))
  1019.     (when (eq (sb-kind sb) :finite)
  1020.       (fill (finite-sb-live-tns sb) nil)))
  1021.  
  1022.   (do-live-tns (tn (ir2-block-live-in block) block)
  1023.     (let* ((sc (tn-sc tn))
  1024.        (sb (sc-sb sc)))
  1025.       (when (eq (sb-kind sb) :finite)
  1026.     (loop for offset from (tn-offset tn)
  1027.           repeat (sc-element-size sc) do
  1028.       (setf (svref (finite-sb-live-tns sb) offset) tn)))))
  1029.  
  1030.   (setq *live-block* block)
  1031.   (setq *live-vop* (ir2-block-last-vop block))
  1032.  
  1033.   (undefined-value))
  1034.  
  1035.  
  1036. ;;; Compute-Live-TNs  --  Internal
  1037. ;;;
  1038. ;;;    Set the Live-TNs in :Finite SBs to represent the TNs live immediately
  1039. ;;; after the evaluation of VOP in Block, excluding results of the VOP.  If VOP
  1040. ;;; is null, then compute the live TNs at the beginning of the block.
  1041. ;;; Sequential calls on the same block must be in reverse VOP order.
  1042. ;;;
  1043. (defun compute-live-tns (block vop)
  1044.   (declare (type ir2-block block) (type vop vop))
  1045.   (unless (eq block *live-block*)
  1046.     (init-live-tns block))
  1047.   
  1048.   (do ((current *live-vop* (vop-prev current)))
  1049.       ((eq current vop)
  1050.        (do ((res (vop-results vop) (tn-ref-across res)))
  1051.        ((null res))
  1052.      (let* ((tn (tn-ref-tn res))
  1053.         (sc (tn-sc tn))
  1054.         (sb (sc-sb sc)))
  1055.        (when (eq (sb-kind sb) :finite)
  1056.          (loop for offset from (tn-offset tn)
  1057.                repeat (sc-element-size sc) do
  1058.            (setf (svref (finite-sb-live-tns sb) offset) nil))))))
  1059.     (do ((ref (vop-refs current) (tn-ref-next-ref ref)))
  1060.     ((null ref))
  1061.       (let ((ltn (tn-ref-load-tn ref)))
  1062.     (when ltn
  1063.       (let* ((sc (tn-sc ltn))
  1064.          (sb (sc-sb sc)))
  1065.         (when (eq (sb-kind sb) :finite)
  1066.           (let ((tns (finite-sb-live-tns sb)))
  1067.         (loop for offset from (tn-offset ltn)
  1068.               repeat (sc-element-size sc) do
  1069.           (assert (null (svref tns offset)))))))))
  1070.  
  1071.       (let* ((tn (tn-ref-tn ref))
  1072.          (sc (tn-sc tn))
  1073.          (sb (sc-sb sc)))
  1074.     (when (eq (sb-kind sb) :finite)
  1075.       (let ((tns (finite-sb-live-tns sb)))
  1076.         (loop for offset from (tn-offset tn)
  1077.               repeat (sc-element-size sc) do
  1078.           (if (tn-ref-write-p ref)
  1079.           (setf (svref tns offset) nil)
  1080.           (let ((old (svref tns offset)))
  1081.             (assert (or (null old) (eq old tn)) (old tn))
  1082.             (setf (svref tns offset) tn)))))))))
  1083.  
  1084.   (setq *live-vop* vop)
  1085.   (undefined-value))
  1086.  
  1087.  
  1088. ;;; LOAD-TN-OFFSET-CONFLICTS-IN-SB  --  Internal
  1089. ;;;
  1090. ;;;    Kind of like Offset-Conflicts-In-SB, except that it uses the VOP refs to
  1091. ;;; determine whether a Load-TN for OP could be packed in the specified
  1092. ;;; location, disregarding conflicts with TNs not referenced by this VOP.
  1093. ;;; There is a conflict if either:
  1094. ;;;  1] The reference is a result, and the same location is either:
  1095. ;;;     -- Used by some other result.
  1096. ;;;     -- Used in any way after the reference (exclusive).
  1097. ;;;  2] The reference is an argument, and the same location is either:
  1098. ;;;     -- Used by some other argument.
  1099. ;;;     -- Used in any way before the reference (exclusive).
  1100. ;;;
  1101. ;;;    In 1 (and 2) above, the first bullet corresponds to result-result
  1102. ;;; (and argument-argument) conflicts.  We need this case because there aren't
  1103. ;;; any TN-REFs to represent the implicit reading of results or writing of
  1104. ;;; arguments.
  1105. ;;;
  1106. ;;;    The second bullet corresponds conflicts with temporaries or between
  1107. ;;; arguments and results.
  1108. ;;;
  1109. ;;;    We consider both the TN-REF-TN and the TN-REF-LOAD-TN (if any) to be
  1110. ;;; referenced simultaneously and in the same way.  This causes load-TNs to
  1111. ;;; appear live to the beginning (or end) of the VOP, as appropriate.
  1112. ;;;
  1113. ;;; We return a conflicting TN if there is a conflict.
  1114. ;;;
  1115. (defun load-tn-offset-conflicts-in-sb (op sb offset)
  1116.   (declare (type tn-ref op) (type finite-sb sb) (type index offset))
  1117.   (assert (eq (sb-kind sb) :finite))
  1118.   (let ((vop (tn-ref-vop op)))
  1119.     (labels ((tn-overlaps (tn)
  1120.            (let ((sc (tn-sc tn))
  1121.              (tn-offset (tn-offset tn)))
  1122.          (when (and (eq (sc-sb sc) sb)
  1123.                 (<= tn-offset offset)
  1124.                 (< offset
  1125.                    (the index
  1126.                     (+ tn-offset (sc-element-size sc)))))
  1127.            tn)))
  1128.          (same (ref)
  1129.            (let ((tn (tn-ref-tn ref))
  1130.              (ltn (tn-ref-load-tn ref)))
  1131.          (or (tn-overlaps tn)
  1132.              (and ltn (tn-overlaps ltn)))))
  1133.          (is-op (ops)
  1134.            (do ((ops ops (tn-ref-across ops)))
  1135.            ((null ops) nil)
  1136.          (let ((found (same ops)))
  1137.            (when (and found (not (eq ops op)))
  1138.              (return found)))))
  1139.          (is-ref (refs end)
  1140.            (do ((refs refs (tn-ref-next-ref refs)))
  1141.            ((eq refs end) nil)
  1142.          (let ((found (same refs)))
  1143.          (when found (return found))))))
  1144.       (declare (inline is-op is-ref tn-overlaps))
  1145.       (if (tn-ref-write-p op)
  1146.       (or (is-op (vop-results vop))
  1147.           (is-ref (vop-refs vop) op))
  1148.       (or (is-op (vop-args vop))
  1149.           (is-ref (tn-ref-next-ref op) nil))))))
  1150.  
  1151.  
  1152. ;;; LOAD-TN-CONFLICTS-IN-SC  --  Internal
  1153. ;;;
  1154. ;;;    Iterate over all the elements in the SB that would be allocated by
  1155. ;;; allocating a TN in SC at Offset, checking for conflict with load-TNs or
  1156. ;;; other TNs (live in the LIVE-TNS, which must be set up.)  We also return
  1157. ;;; true if there aren't enough locations after Offset to hold a TN in SC.
  1158. ;;; If Ignore-Live is true, then we ignore the live-TNs, considering only
  1159. ;;; references within Op's VOP.
  1160. ;;;
  1161. ;;;    We return a conflicting TN, or :OVERFLOW if the TN won't fit.
  1162. ;;;
  1163. (defun load-tn-conflicts-in-sc (op sc offset ignore-live)
  1164.   (let* ((sb (sc-sb sc))
  1165.      (size (finite-sb-current-size sb)))
  1166.     (loop for i from offset
  1167.           repeat (sc-element-size sc)
  1168.           thereis (or (when (>= i size) :overflow)
  1169.               (and (not ignore-live)
  1170.                (svref (finite-sb-live-tns sb) offset))
  1171.               (load-tn-offset-conflicts-in-sb op sb i)))))
  1172.  
  1173.  
  1174. ;;; Find-Load-TN-Target  --  Internal
  1175. ;;;
  1176. ;;;    If a load-TN for Op is targeted to a legal location in SC, then return
  1177. ;;; the offset, otherwise return NIL.  We see if the target of the operand is
  1178. ;;; packed, and try that location.  There isn't any need to chain down the
  1179. ;;; target path, since everything is packed now.
  1180. ;;;
  1181. ;;;    We require the target to be in SC (and not merely to overlap with SC).
  1182. ;;; This prevents SC information from being lost in load TNs (we won't pack a
  1183. ;;; load TN in ANY-REG when it is targeted to a DESCRIPTOR-REG.)  This
  1184. ;;; shouldn't hurt the code as long as all relevant overlapping SCs are allowed
  1185. ;;; in the operand SC restriction.
  1186. ;;;
  1187. (defun find-load-tn-target (op sc)
  1188.   (declare (inline member))
  1189.   (let ((target (tn-ref-target op)))
  1190.     (when target
  1191.       (let* ((tn (tn-ref-tn target))
  1192.          (loc (tn-offset tn)))
  1193.     (if (and (eq (tn-sc tn) sc)
  1194.          (member (the index loc) (sc-locations sc))
  1195.          (not (load-tn-conflicts-in-sc op sc loc nil)))
  1196.         loc
  1197.         nil)))))
  1198.  
  1199.  
  1200. ;;; Select-Load-Tn-Location  --  Internal
  1201. ;;;
  1202. ;;;    Select a legal location for a load TN for Op in SC.  We just iterate
  1203. ;;; over the SC's locations.  If we can't find a legal location, return NIL.
  1204. ;;;
  1205. (defun select-load-tn-location (op sc)
  1206.   (declare (type tn-ref op) (type sc sc))
  1207.   (dolist (loc (sc-locations sc) nil)
  1208.     (unless (load-tn-conflicts-in-sc op sc loc nil)
  1209.       (return loc))))
  1210.  
  1211.  
  1212. (defevent unpack-tn "Unpacked a TN to satisfy operand SC restriction.")
  1213.  
  1214. ;;; UNPACK-TN  --  Internal
  1215. ;;;
  1216. ;;;    Make TN's location the same as for its save TN (allocating a save TN if
  1217. ;;; necessary.)  Delete any save/restore code that has been emitted thus far.
  1218. ;;; Mark all blocks containing references as needing to be repacked.
  1219. ;;;
  1220. (defun unpack-tn (tn)
  1221.   (event unpack-tn)
  1222.   (let ((stn (or (tn-save-tn tn)
  1223.          (pack-save-tn tn))))
  1224.     (setf (tn-sc tn) (tn-sc stn))
  1225.     (setf (tn-offset tn) (tn-offset stn))
  1226.     (flet ((zot (refs)
  1227.          (do ((ref refs (tn-ref-next ref)))
  1228.          ((null ref))
  1229.            (let ((vop (tn-ref-vop ref)))
  1230.          (if (eq (vop-info-name (vop-info vop)) 'move-operand)
  1231.              (delete-vop vop)
  1232.              (setf (gethash (vop-block vop) *repack-blocks*) t))))))
  1233.       (zot (tn-reads tn))
  1234.       (zot (tn-writes tn))))
  1235.  
  1236.   (undefined-value))
  1237.  
  1238. (defevent unpack-fallback "Unpacked some random operand TN.")
  1239.  
  1240. ;;; UNPACK-FOR-LOAD-TN  --  Internal
  1241. ;;;
  1242. ;;;     Called by Pack-Load-TN where there isn't any location free that we can
  1243. ;;; pack into.  What we do is move some live TN in one of the specified SCs to
  1244. ;;; memory, then mark this block all blocks that reference the TN as needing
  1245. ;;; repacking.  If we suceed, we throw to UNPACKED-TN.  If we fail, we return
  1246. ;;; NIL.
  1247. ;;;
  1248. ;;; We can unpack any live TN that appears in the NORMAL-TNs list (isn't wired
  1249. ;;; or restricted.)  We prefer to unpack TNs that are not used by the VOP.  If
  1250. ;;; we can't find any such TN, then we unpack some random argument or result
  1251. ;;; TN.  The only way we can fail is if all locations in SC are used by
  1252. ;;; load-TNs or temporaries in VOP.
  1253. ;;;
  1254. (defun unpack-for-load-tn (sc op)
  1255.   (declare (type sc sc) (type tn-ref op))
  1256.   (let ((sb (sc-sb sc))
  1257.     (normal-tns (ir2-component-normal-tns
  1258.              (component-info *compile-component*)))
  1259.     (node (vop-node (tn-ref-vop op)))
  1260.     (fallback nil))
  1261.     (flet ((unpack-em (victims)
  1262.          (unless *repack-blocks*
  1263.            (setq *repack-blocks* (make-hash-table :test #'eq)))
  1264.          (setf (gethash (vop-block (tn-ref-vop op)) *repack-blocks*) t)
  1265.          (dolist (victim victims)
  1266.            (event unpack-tn node)
  1267.            (unpack-tn victim))
  1268.          (throw 'unpacked-tn nil)))
  1269.       (dolist (loc (sc-locations sc))
  1270.     (declare (type index loc))
  1271.     (block SKIP
  1272.       (collect ((victims nil adjoin))
  1273.         (loop for i from loc
  1274.           as victim = (svref (finite-sb-live-tns sb) i)
  1275.           repeat (sc-element-size sc) do
  1276.           (when victim
  1277.         (unless (find-in #'tn-next victim normal-tns)
  1278.           (return-from SKIP))
  1279.         (victims victim)))
  1280.         
  1281.         (let ((conf (load-tn-conflicts-in-sc op sc loc t)))
  1282.           (cond ((not conf)
  1283.              (unpack-em (victims)))
  1284.             ((eq conf :overflow))
  1285.             ((not fallback)
  1286.              (cond ((find conf (victims))
  1287.                 (setq fallback (victims)))
  1288.                ((find-in #'tn-next conf normal-tns)
  1289.                 (setq fallback (list conf))))))))))
  1290.       
  1291.       (when fallback
  1292.     (event unpack-fallback node)
  1293.     (unpack-em fallback))))
  1294.  
  1295.   nil)
  1296.  
  1297.  
  1298. ;;; Pack-Load-TN  --  Internal
  1299. ;;;
  1300. ;;;    Try to pack a load TN in the SCs indicated by Load-SCs.  If we run out
  1301. ;;; of SCs, then we unpack some TN and try again.  We return the packed load
  1302. ;;; TN.
  1303. ;;;
  1304. ;;; Note: we allow a Load-TN to be packed in the target location even if that
  1305. ;;; location is in a SC not allowed by the primitive type.  (The SC must still
  1306. ;;; be allowed by the operand restriction.)  This makes move VOPs more
  1307. ;;; efficient, since we won't do a move from the stack into a non-descriptor
  1308. ;;; any-reg though a descriptor argument load-TN.  This does give targeting
  1309. ;;; some real semantics, making it not a pure advisory to pack.  It allows pack
  1310. ;;; to do some packing it wouldn't have done before.
  1311. ;;;
  1312. (defun pack-load-tn (load-scs op)
  1313.   (declare (type sc-vector load-scs) (type tn-ref op))
  1314.   (let ((vop (tn-ref-vop op)))
  1315.     (compute-live-tns (vop-block vop) vop))
  1316.   
  1317.   (let* ((tn (tn-ref-tn op))
  1318.      (ptype (tn-primitive-type tn))
  1319.      (scs (svref load-scs (sc-number (tn-sc tn)))))
  1320.     (let ((current-scs scs)
  1321.       (allowed ()))
  1322.       (loop
  1323.     (cond
  1324.      ((null current-scs)
  1325.       (unless allowed
  1326.         (no-load-scs-allowed-by-primitive-type-error op))
  1327.       (dolist (sc allowed)
  1328.         (unpack-for-load-tn sc op))
  1329.       (failed-to-pack-load-tn-error allowed op))
  1330.     (t
  1331.      (let* ((sc (svref (backend-sc-numbers *backend*) (pop current-scs)))
  1332.         (target (find-load-tn-target op sc)))
  1333.        (when (or target (sc-allowed-by-primitive-type sc ptype))
  1334.          (let ((loc (or target
  1335.                 (select-load-tn-location op sc))))
  1336.            (when loc
  1337.          (let ((res (make-tn 0 :load nil sc)))
  1338.            (setf (tn-offset res) loc)
  1339.            (return res))))
  1340.          (push sc allowed)))))))))
  1341.  
  1342.  
  1343. ;;; Check-Operand-Restrictions  --  Internal
  1344. ;;;
  1345. ;;;    Scan a list of load-SCs vectors and a list of TN-Refs threaded by
  1346. ;;; TN-Ref-Across.  When we find a reference whose TN doesn't satisfy the
  1347. ;;; restriction, we pack a Load-TN and load the operand into it.  If a load-tn
  1348. ;;; has already been allocated, we can assume that the restriction is
  1349. ;;; satisfied.
  1350. ;;;
  1351. (proclaim '(inline check-operand-restrictions))
  1352. (defun check-operand-restrictions (scs ops)
  1353.   (declare (list scs) (type (or tn-ref null) ops))
  1354.   (do ((scs scs (cdr scs))
  1355.        (op ops (tn-ref-across op)))
  1356.       ((null scs))
  1357.     (let* ((load-tn (tn-ref-load-tn op))
  1358.        (load-scs (svref (car scs)
  1359.                 (sc-number (tn-sc (or load-tn (tn-ref-tn op)))))))
  1360.       (if load-tn
  1361.       (assert (eq load-scs t))
  1362.       (unless (eq load-scs t)
  1363.         (setf (tn-ref-load-tn op) (pack-load-tn (car scs) op))))))
  1364.   (undefined-value))
  1365.     
  1366.  
  1367. ;;; Pack-Load-TNs  --  Internal
  1368. ;;;
  1369. ;;;    Scan the VOPs in Block, looking for operands whose SC restrictions
  1370. ;;; aren't statisfied.  We do the results first, since they are evaluated
  1371. ;;; later, and our conflict analysis is a backward scan.
  1372. ;;;
  1373. (defun pack-load-tns (block)
  1374.   (catch 'unpacked-tn
  1375.     (do ((vop (ir2-block-last-vop block) (vop-prev vop)))
  1376.     ((null vop))
  1377.       (let ((info (vop-info vop)))
  1378.     (check-operand-restrictions (vop-info-result-load-scs info)
  1379.                     (vop-results vop))
  1380.     (check-operand-restrictions (vop-info-arg-load-scs info)
  1381.                     (vop-args vop)))))
  1382.   (undefined-value))
  1383.  
  1384.  
  1385. ;;; Pack-TN  --  Internal
  1386. ;;;
  1387. ;;;    Attempt to pack TN in all possible SCs, first in the SC chosen by
  1388. ;;; representation selection, then in the alternate SCs in the order they were
  1389. ;;; specified in the SC definition.  If the TN-COST is negative, then we
  1390. ;;; don't attempt to pack in SCs that must be saved.  If Restricted, then we
  1391. ;;; can only pack in TN-SC, not in any Alternate-SCs.
  1392. ;;;
  1393. ;;;    If we are attempting to pack in the SC of the save TN for a TN with a
  1394. ;;; :SPECIFIED-SAVE TN, then we pack in that location, instead of allocating a
  1395. ;;; new stack location.
  1396. ;;;
  1397. (defun pack-tn (tn restricted)
  1398.   (declare (type tn tn))
  1399.   (let* ((original (original-tn tn))
  1400.      (fsc (tn-sc tn))
  1401.      (alternates (unless restricted (sc-alternate-scs fsc)))
  1402.      (save (tn-save-tn tn))
  1403.      (specified-save-sc
  1404.       (when (and save
  1405.              (eq (tn-kind save) :specified-save))
  1406.         (tn-sc save))))
  1407.  
  1408.     (do ((sc fsc (pop alternates)))
  1409.     ((null sc)
  1410.      (failed-to-pack-error tn restricted))
  1411.       (when (eq sc specified-save-sc)
  1412.     (unless (tn-offset save)
  1413.       (pack-tn save nil))
  1414.     (setf (tn-offset tn) (tn-offset save))
  1415.     (setf (tn-sc tn) (tn-sc save))
  1416.     (return))
  1417.       (when (or restricted
  1418.         (not (and (minusp (tn-cost tn)) (sc-save-p sc))))
  1419.     (let ((loc (or (find-ok-target-offset original sc)
  1420.                (select-location original sc)
  1421.                (when (eq (sb-kind (sc-sb sc)) :unbounded)
  1422.              (grow-sc sc)
  1423.              (or (select-location original sc)
  1424.                  (error "Failed to pack after growing SC?"))))))
  1425.       (when loc
  1426.         (add-location-conflicts original sc loc)
  1427.         (setf (tn-sc tn) sc)
  1428.         (setf (tn-offset tn) loc)
  1429.         (return))))))
  1430.         
  1431.   (undefined-value))
  1432.  
  1433.  
  1434. ;;; Pack-Wired-TN  --  Internal
  1435. ;;;
  1436. ;;;    Pack a wired TN, checking that the offset is in bounds for the SB, and
  1437. ;;; that the TN doesn't conflict with some other TN already packed in that
  1438. ;;; location.  If the TN is wired to a location beyond the end of a :Unbounded
  1439. ;;; SB, then grow the SB enough to hold the TN.
  1440. ;;;
  1441. ;;; ### Checking for conflicts is disabled for :SPECIFIED-SAVE TNs.  This is
  1442. ;;; kind of a hack to make specifying wired stack save locations for local call
  1443. ;;; arguments (such as OLD-FP) work, since the caller and callee OLD-FP save
  1444. ;;; locations may conflict when the save locations don't really (due to being
  1445. ;;; in different frames.)
  1446. ;;;
  1447. (defun pack-wired-tn (tn)
  1448.   (declare (type tn tn))
  1449.   (let* ((sc (tn-sc tn))
  1450.      (sb (sc-sb sc))
  1451.      (offset (tn-offset tn))
  1452.      (end (+ offset (sc-element-size sc)))
  1453.      (original (original-tn tn)))
  1454.     (when (> end (finite-sb-current-size sb))
  1455.       (unless (eq (sb-kind sb) :unbounded)
  1456.     (error "~S wired to a location that is out of bounds." tn))
  1457.       (grow-sc sc end))
  1458.     (when (and (not (eq (tn-kind tn) :specified-save))
  1459.            (conflicts-in-sc original sc offset))
  1460.       (error "~S wired to a location that it conflicts with." tn))
  1461.     (add-location-conflicts original sc offset)))
  1462.  
  1463.  
  1464. (defevent repack-block "Repacked a block due to TN unpacking.")
  1465.  
  1466. ;;; Pack  --  Interface
  1467. ;;;
  1468. (defun pack (component)
  1469.   (assert (not *in-pack*))
  1470.   (let ((*in-pack* t)
  1471.     (optimize (policy nil (or (>= speed cspeed) (>= space cspeed))))
  1472.     (2comp (component-info component)))
  1473.     (init-sb-vectors component)
  1474.     ;;
  1475.     ;; Call the target functions.
  1476.     (do-ir2-blocks (block component)
  1477.       (do ((vop (ir2-block-start-vop block) (vop-next vop)))
  1478.       ((null vop))
  1479.     (let ((target-fun (vop-info-target-function (vop-info vop))))
  1480.       (when target-fun
  1481.         (funcall target-fun vop)))))
  1482.     
  1483.     ;;
  1484.     ;; Pack wired TNs first.
  1485.     (do ((tn (ir2-component-wired-tns 2comp) (tn-next tn)))
  1486.     ((null tn))
  1487.       (pack-wired-tn tn))
  1488.     ;;
  1489.     ;; Pack restricted component TNs.
  1490.     (do ((tn (ir2-component-restricted-tns 2comp) (tn-next tn)))
  1491.     ((null tn))
  1492.       (when (eq (tn-kind tn) :component)
  1493.     (pack-tn tn t)))
  1494.     ;;
  1495.     ;; Pack other restricted TNs.
  1496.     (do ((tn (ir2-component-restricted-tns 2comp) (tn-next tn)))
  1497.     ((null tn))
  1498.       (unless (tn-offset tn)
  1499.     (pack-tn tn t)))
  1500.     ;;
  1501.     ;; Assign costs to normal TNs so we know which ones should always be
  1502.     ;; packed on the stack.
  1503.     (when (and optimize pack-assign-costs)
  1504.       (assign-tn-costs component))
  1505.     ;;
  1506.     ;; Pack normal TNs in the order that they appear in the code.  This
  1507.     ;; should have some tendency to pack important TNs first, since control
  1508.     ;; analysis favors the drop-through.  This should also help targeting,
  1509.     ;; since we will pack the target TN soon after we determine the location
  1510.     ;; of the targeting TN.
  1511.     (do-ir2-blocks (block component)
  1512.       (let ((ltns (ir2-block-local-tns block)))
  1513.     (do ((i (1- (ir2-block-local-tn-count block)) (1- i)))
  1514.         ((minusp i))
  1515.       (declare (fixnum i))
  1516.       (let ((tn (svref ltns i)))
  1517.         (unless (or (null tn) (eq tn :more) (tn-offset tn))
  1518.           (pack-tn tn nil))))))
  1519.     ;;
  1520.     ;; Pack any leftover normal TNs.  This is to deal with :MORE TNs, which
  1521.     ;; could possibly not appear in any local TN map.
  1522.     (do ((tn (ir2-component-normal-tns 2comp) (tn-next tn)))
  1523.     ((null tn))
  1524.       (unless (tn-offset tn)
  1525.     (pack-tn tn nil)))
  1526.     ;;
  1527.     ;; Do load TN packing and emit saves.
  1528.     (let ((*repack-blocks* nil))
  1529.       (let ((*live-block* nil)
  1530.         (*live-vop* nil))
  1531.     (cond ((and optimize pack-optimize-saves)
  1532.            (optimized-emit-saves component)
  1533.            (do-ir2-blocks (block component)
  1534.          (pack-load-tns block)))
  1535.           (t
  1536.            (do-ir2-blocks (block component)
  1537.          (emit-saves block)
  1538.          (pack-load-tns block)))))
  1539.       (when *repack-blocks*
  1540.     (loop
  1541.       (when (zerop (hash-table-count *repack-blocks*)) (return))
  1542.       (let ((*live-block* nil)
  1543.         (*live-vop* nil))
  1544.         (maphash #'(lambda (block v)
  1545.              (declare (ignore v))
  1546.              (remhash block *repack-blocks*)
  1547.              (event repack-block)
  1548.              (pack-load-tns block))
  1549.              *repack-blocks*)))))
  1550.  
  1551.     (undefined-value)))
  1552.